home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / comm / s342q07.lha / datachng.c < prev    next >
C/C++ Source or Header  |  1994-11-15  |  15KB  |  631 lines
  1. /*
  2. *                Datachng.c
  3. *
  4. * Data expander and shrinker for C-86.
  5. */
  6. /*
  7. *                history
  8. *
  9. * 89Apr13 HAW  Fix problem with expanding shared rooms (V1.3)
  10. * 87Nov30 HAW  Fix problem with expanding rooms (V1.2)
  11. * 87Nov?? HAW  Fix problem with reducing Mail.
  12. * 87Oct12 HAW  Modified from Lexpand.
  13. * 85Nov16 HAW  Modified for MS-DOS libraries.
  14. * 85May23 HAW  Created.
  15. */
  16. #include "ctdl.h"    /* header file  */
  17. #include <stdio.h>
  18. #include <string.h>
  19. #include <stdlib.h>
  20. #include <math.h>
  21. #include <ctype.h>
  22. #include <time.h>
  23. #include <proto/exec.h>
  24. #include <dos/dos.h>
  25. #include <pragmas/dos_pragmas.h>
  26. #include "exec/memory.h"
  27. #include "exec/ports.h"
  28. #include "exec/exec.h"
  29. /*
  30. *                Contents
  31. *
  32. *    crashout()        irrecoverable error
  33. *    getUtilNumber()        prompt user for a number, limited range
  34. *    init()            initialization
  35. *    main()            main controller
  36. *    openFile()        opens a .sys file
  37. */
  38. #define DoFree(p)       if ((p) != NULL)  {  free(p);  }
  39. #define VERSION        "V3.42"
  40. extern CONFIG    cfg;
  41. extern LogTable  *logTab;    /* RAM index of pippuls    */
  42. extern logBuffer logBuf;    /* Pippul buffer    */
  43. extern aRoom     roomBuf;
  44. extern NetBuffer netBuf;
  45. extern rTable    *roomTab;
  46. extern NetTable  *netTab;
  47. extern FILE      *logfl;    /* log file descriptor    */
  48. extern FILE      *roomfl;
  49. extern FILE      *netfl;
  50. #ifdef ANSI_PROTOTYPING
  51. int  getUtilNumber(char *prompt, unsigned bottom, unsigned top);
  52. void getUtilString(char *prompt, char *buf, int lim);
  53. void init(void);
  54. void menus(void);
  55. void LogExpand(void);
  56. void RoomHandler(void);
  57. void LogGenChange(int NewSize);
  58. void MsgHandler(void);
  59. void remakeRoomFl(void);
  60. void remakeLogFl(void);
  61. void remakeNetFl(void);
  62. void MailHandler(void);
  63. int  NEUtilGetch(void);
  64. int  UtilGetch(void);
  65. void SharedHandler(void);
  66. void NetArchHandler(void);
  67. char getUYesNo(char *prompt);
  68. #endif
  69.  
  70. int  mPrintf(char *format, ...) {return 0; }  /* stub to quiet the linker */
  71.  
  72. /*
  73. * crashout()
  74. *
  75. * This handles the irrecoverable error.
  76. */
  77. void crashout(str)
  78. char *str;
  79.   {
  80.   exit(printf(str));
  81.  
  82.   }
  83. /*
  84. * getUtilNumber()
  85. *
  86. * This function prompts for a number in (bottom, top) range.
  87. */
  88. int getUtilNumber(prompt, bottom, top)
  89. char   *prompt;
  90. unsigned bottom;
  91. unsigned top;
  92.   {
  93.   int try;
  94.   char numstring[NAMESIZE];
  95.   do
  96.     {
  97.     getUtilString(prompt, numstring, NAMESIZE);
  98.     try     = atoi(numstring);
  99.     if (try < bottom)  printf("Sorry, must be at least %d\n", bottom);
  100.     if (try > top   )  printf("Sorry, must be no more than %d\n", top);
  101.  
  102.     }
  103.   while (try < bottom ||  try > top);
  104.   return  try;
  105.  
  106.   }
  107. /*
  108. * getUtilString()
  109. *
  110. * This function gets a string from the user.
  111. */
  112. void getUtilString(prompt, buf, lim)
  113. char *prompt;
  114. char *buf;
  115. int  lim;       /* max # chars to read */
  116.   {
  117.   char c;
  118.   int  i;
  119.   if(strLen(prompt) > 0)
  120.     {
  121.     printf("\nEnter %s : ", prompt, lim);
  122.  
  123.     };
  124.   i   = 0;
  125.   while (    (c = getchar()) !='\n' && i < lim )
  126.     {
  127.     buf[i++] = c;
  128.     };
  129.   buf[i]  = '\0';
  130.   if( i == lim )while ( getchar() != '\n');
  131.   putchar('\n');
  132.  
  133.   }
  134. /*
  135. * getUYesNo()
  136. *
  137. * This handles a yes/no question.
  138. */
  139. char getUYesNo(prompt)
  140. char *prompt;
  141.   {
  142.   int  toReturn = ERROR;
  143.   char c;
  144.   do
  145.     {
  146.     printf("\n%s? (Y/N)", prompt);
  147.     c = getchar();
  148.     while( getchar() != '\n');
  149.     switch ( toUpper(c) )
  150.       {
  151.       case 'Y': toReturn = TRUE; break;
  152.       case 'N': toReturn = FALSE; break;
  153.       default: printf("You must answer Yes or No\n");
  154.       }
  155.     }
  156.   while (toReturn == ERROR);
  157.   return (char)toReturn;
  158.  
  159.   }
  160. /*
  161. * init()
  162. *
  163. * This handles initializization details.
  164. */
  165. void init()
  166.   {
  167.   SYS_FILE tempname;
  168.   cfg.weAre = UTILITY;
  169.   if (!readSysTab(FALSE, TRUE)) exit(1);  /* No system table? Tacky, tacky*/
  170.   if (access(LOCKFILE, 0) != -1)
  171.     {
  172.     printf("Please do not run DataChng using Outside Commands.\n");
  173.     exit(1);
  174.  
  175.     }
  176.   mvToHomeDisk(&cfg.homeArea);
  177.   makeSysName(tempname, "ctdllog.sys", &cfg.logArea);
  178.   openFile(tempname,  &logfl );
  179.   makeSysName(tempname, "ctdlroom.sys", &cfg.roomArea);
  180.   openFile(tempname,  &roomfl );
  181.   if (cfg.BoolFlags.netParticipant)
  182.     {
  183.     makeSysName(tempname, "ctdlnet.sys", &cfg.netArea);
  184.     openFile(tempname,  &netfl );
  185.     initNetBuf(&netBuf);
  186.  
  187.     }
  188.   initLogBuf(&logBuf);
  189.   initRoomBuf(&roomBuf);
  190.  
  191.   }
  192. /*
  193. * main()
  194. *
  195. * This is the main controller.
  196. */
  197. int main(void);
  198. int main()
  199.   {
  200.   printf("DATACHNG %s\n%s\n", VERSION,COPYRIGHT);
  201.   init();
  202.   menus();
  203.   return 0;
  204.   }
  205. /*
  206. * menus()
  207. *
  208. * Menu stuff.
  209. */
  210. void menus()
  211.   {
  212.   char c;
  213.   char done = FALSE;
  214.   if (!getUYesNo("HAVE YOU BACKED UP YOUR SYSTEM YET")) crashout("THEN DO SO FIRST!");
  215.   do
  216.     {
  217.     printf("\n\n\n%20c Citadel Data Changer (%s)\n\n", ' ', VERSION);
  218.     printf("a) Expand log (presently %d accounts)\n", cfg.MAXLOGTAB);
  219.     printf("b) Expand or contract room table (presently %d slots)\n", MAXROOMS);
  220.     printf("c) Expand or contract the number of messages per room ");
  221.     printf("(presently %d slots)\n", MSGSPERRM);
  222.     printf("d) Expand or contract the number of Mail messages per user ");
  223.     printf("(presently %d slots)\n", MAILSLOTS);
  224.     if (cfg.BoolFlags.netParticipant)
  225.       {
  226.       printf("e) Expand or contract the number of shared rooms/system ");
  227.       printf("(presently %d rooms)\n", SHARED_ROOMS);
  228.  
  229.       }
  230.     c = getchar();
  231.     while( getchar() != '\n');
  232.     switch (toUpper(c))
  233.       {
  234.       case 'A': LogExpand();    break;
  235.       case 'B': RoomHandler();  break;
  236.       case 'C': MsgHandler();      break;
  237.       case 'D': MailHandler();  break;
  238.       case 'E':    if (cfg.BoolFlags.netParticipant)
  239.         {
  240.         SharedHandler();    break;
  241.  
  242.         }
  243.       default: done = TRUE;        break;
  244.  
  245.       }
  246.     if (!done) writeSysTab();
  247.  
  248.     }
  249.   while (!done);
  250.  
  251.   }
  252. /*
  253. * LogExpand()
  254. *
  255. * This function handles expanding the user log.
  256. */
  257. void LogExpand()
  258.   {
  259.   int i, j;
  260.   printf("Current log size is %d\n", cfg.MAXLOGTAB);
  261.   i = getUtilNumber("New size", cfg.MAXLOGTAB, 65535);
  262.   if (i > cfg.MAXLOGTAB)
  263.     {
  264.     logTab = (LogTable *) realloc(logTab, sizeof(*logTab) * i);
  265.     logBuf.lbname[0]      = 0;
  266.     logBuf.lbpw[0]    = 0;
  267.     logBuf.lbflags.L_INUSE = FALSE;
  268.     for (j = cfg.MAXLOGTAB; j < i; j++)
  269.       {
  270.       putLog(&logBuf, j);
  271.       logTab[j].ltpwhash  = 0;
  272.       logTab[j].ltnmhash  = 0;
  273.       logTab[j].ltlogSlot = j;
  274.       printf("Clearing %d\r", j);
  275.  
  276.       }
  277.     cfg.MAXLOGTAB = i;
  278.  
  279.     }
  280.   printf("Don't forget to update LOGSIZE in CTDLCNFG.SYS with %d!\n",
  281.   cfg.MAXLOGTAB);
  282.  
  283.   }
  284. /*
  285. * RoomHandler()
  286. *
  287. * This handles the expansion or contraction of the room file.
  288. */
  289. void RoomHandler()
  290.   {
  291.   int NewSize, i;
  292.   aRoom *TempTab;
  293.   extern char *WRITE_ANY;
  294.   printf("Current room size is %d\n", MAXROOMS);
  295.   NewSize = getUtilNumber("New size", 3, 65535);
  296.   if (NewSize == MAXROOMS) return ;
  297.   if (NewSize < MAXROOMS)
  298.     {
  299.     for (i = MAXROOMS-1; i >= NewSize; i--)
  300.     if (roomTab[i].rtflags.INUSE)
  301.       {
  302.       printf(
  303.       "A room called '%s' will be lost.\n", roomTab[i].rtname);
  304.       if (!getUYesNo("Do you still wish to contract the rooms"))
  305.       return;
  306.  
  307.       };
  308.     TempTab = (aRoom *) GetDynamic(sizeof roomBuf * NewSize);
  309.     for (i = 0; i < NewSize; i++)
  310.       {
  311.       getRoom(i);
  312.       movmem(&roomBuf, TempTab+i, sizeof roomBuf);
  313.       TempTab[i].msg = (theMessages *) GetDynamic(MSG_BULK);
  314.       movmem(roomBuf.msg, TempTab[i].msg, MSG_BULK);
  315.  
  316.       }
  317.     remakeRoomFl();
  318.     for (i = 0; i < NewSize; i++)
  319.       {
  320.       movmem(TempTab+i, &roomBuf, RB_SIZE);
  321.       movmem(TempTab[i].msg, roomBuf.msg, MSG_BULK);
  322.       putRoom(i);
  323.       DoFree(TempTab[i].msg);
  324.  
  325.       }
  326.     DoFree(TempTab);
  327.     LogGenChange(NewSize);
  328.  
  329.     }
  330.   else
  331.     {
  332.     roomTab = (rTable *) realloc(roomTab, sizeof *roomTab * NewSize);
  333.     setmem(&roomBuf, RB_SIZE, 0);   /* Zilch all but the pointers */
  334.     setmem(roomBuf.msg, MSG_BULK, 0);
  335.     for (i = MAXROOMS; i <= NewSize; i++)
  336.       {
  337.       zero_struct(roomTab[i]);
  338.       RoomSys(i);
  339.       putRoom(i);
  340.  
  341.       }
  342.     LogGenChange(NewSize);
  343.  
  344.     }
  345.   MAXROOMS = NewSize;
  346.   printf("Please remember to changes MAXROOMS to %d\n\n", MAXROOMS);
  347.  
  348.   }
  349. /*
  350. * LogGenChange()
  351. *
  352. * This function will change the generation array of the log.  This needs to
  353. * be done when the number of rooms in the system changes.
  354. */
  355. void LogGenChange(NewSize)
  356. int NewSize;
  357.   {
  358.   int i, oldSize;
  359.   logBuffer *NewLogs;
  360.   extern char *WRITE_ANY;
  361.   SYS_FILE tempname;
  362.   NewLogs = (logBuffer *) GetDynamic(sizeof logBuf * cfg.MAXLOGTAB);
  363.   for (i = 0; i < cfg.MAXLOGTAB; i++)
  364.     {
  365.     getLog(&logBuf, i);
  366.     if (logBuf.lbflags.L_INUSE) printf("reading %s\n", logBuf.lbname);
  367.     movmem(&logBuf, NewLogs + i, LB_SIZE);
  368.     NewLogs[i].lbgen = (AN_UNSIGNED *) GetDynamic(
  369.     NewSize * sizeof (AN_UNSIGNED));
  370.     setmem(NewLogs[i].lbgen, NewSize * sizeof (AN_UNSIGNED), 0);
  371.     movmem(logBuf.lbgen, NewLogs[i].lbgen,
  372.     minimum(NewSize, MAXROOMS) * sizeof (AN_UNSIGNED));
  373.     NewLogs[i].lbMail = (theMessages *) GetDynamic(MAIL_BULK);
  374.     movmem(logBuf.lbMail, NewLogs[i].lbMail, MAIL_BULK);
  375.  
  376.     }
  377.   oldSize = MAXROOMS;
  378.   MAXROOMS = NewSize;
  379.   fclose(logfl);
  380.   makeSysName(tempname, "ctdllog.sys", &cfg.logArea);
  381.   unlink(tempname);
  382.   if ((logfl = fopen(tempname, WRITE_ANY)) == NULL)
  383.     {
  384.     crashout("Couldn't reopen log file!  (Return to your backups!)");
  385.  
  386.     }
  387.   DoFree(logBuf.lbgen);
  388.   logBuf.lbgen = (AN_UNSIGNED *) GetDynamic(GEN_BULK);
  389.   for (i = 0; i < cfg.MAXLOGTAB; i++)
  390.     {
  391.     movmem(NewLogs + i, &logBuf, LB_SIZE);
  392.     movmem(NewLogs[i].lbgen, logBuf.lbgen, NewSize * sizeof (AN_UNSIGNED));
  393.     movmem(NewLogs[i].lbMail, logBuf.lbMail, MAIL_BULK);
  394.     DoFree(NewLogs[i].lbgen);
  395.     DoFree(NewLogs[i].lbMail);
  396.     putLog(&logBuf, i);
  397.     if (logBuf.lbflags.L_INUSE)
  398.     printf("writing %s\n", logBuf.lbname);
  399.  
  400.     }
  401.   DoFree(NewLogs);
  402.   fclose(logfl);
  403.   openFile(tempname, &logfl);
  404.   MAXROOMS = oldSize;
  405.  
  406.   }
  407. /*
  408. * MsgHandler()
  409. *
  410. * This function handles changes to MSGSPERRM.
  411. */
  412. void MsgHandler()
  413.   {
  414.   int NewSize, i, r1, r2, newBulk;
  415.   aRoom *TempRooms;
  416.   printf("Current messages per room is %d\n", MSGSPERRM);
  417.   NewSize = getUtilNumber("New size", 0, 65535);
  418.   newBulk = sizeof (theMessages) * NewSize;
  419.   if (NewSize == MSGSPERRM) return ;
  420.   TempRooms = (aRoom *) GetDynamic(sizeof roomBuf * MAXROOMS);
  421.   for (i = 0; i < MAXROOMS; i++)
  422.     {
  423.     getRoom(i);
  424.     movmem(&roomBuf, TempRooms+i, RB_SIZE);
  425.     TempRooms[i].msg = (theMessages *) GetDynamic(newBulk);
  426.     setmem(TempRooms[i].msg, newBulk, 0);
  427.     for (r1 = MSGSPERRM - 1, r2 = NewSize - 1;
  428.     r1 != -1 && r2 != -1; r1--, r2--)
  429.       {
  430.       TempRooms[i].msg[r2].rbmsgNo  = roomBuf.msg[r1].rbmsgNo;
  431.       TempRooms[i].msg[r2].rbmsgLoc = roomBuf.msg[r1].rbmsgLoc;
  432.  
  433.       }
  434.  
  435.     }
  436.   remakeRoomFl();
  437.   killRoomBuf(&roomBuf);
  438.   MSGSPERRM = NewSize;
  439.   for (i = 0; i < MAXROOMS; i++)
  440.     {
  441.     movmem(TempRooms+i, &roomBuf, RB_SIZE);
  442.     roomBuf.msg = TempRooms[i].msg;    /* Cheat */
  443.     putRoom(i);
  444.     DoFree(TempRooms[i].msg);
  445.  
  446.     }
  447.   DoFree(TempRooms);
  448.   initRoomBuf(&roomBuf);
  449.   printf("Please remember to change MSG-SLOTS to %d\n\n", MSGSPERRM);
  450.  
  451.   }
  452. /*
  453. * remakeRoomFl()
  454. *
  455. * This function handles killing and re-opening the room file.
  456. */
  457. void remakeRoomFl()
  458.   {
  459.   SYS_FILE tempname;
  460.   extern char *W_R_ANY;
  461.   fclose(roomfl);
  462.   makeSysName(tempname, "ctdlroom.sys", &cfg.roomArea);
  463.   unlink(tempname);
  464.   if ((roomfl = fopen(tempname, W_R_ANY)) == NULL)
  465.     {
  466.     crashout("Couldn't reopen room file!  (Return to your backups!)");
  467.  
  468.     }
  469.  
  470.   }
  471. /*
  472. * remakeLogFl()
  473. *
  474. * This function handles killing and re-opening the log file.
  475. */
  476. void remakeLogFl()
  477.   {
  478.   SYS_FILE tempname;
  479.   extern char *W_R_ANY;
  480.   fclose(logfl);
  481.   makeSysName(tempname, "ctdllog.sys", &cfg.logArea);
  482.   unlink(tempname);
  483.   if ((logfl = fopen(tempname, W_R_ANY)) == NULL)
  484.     {
  485.     crashout("Couldn't reopen log file!  (Return to your backups!)");
  486.  
  487.     }
  488.  
  489.   }
  490. /*
  491. * remakeNetFl()
  492. *
  493. * This function handles killing and re-opening the net file.
  494. */
  495. void remakeNetFl()
  496.   {
  497.   SYS_FILE tempname;
  498.   extern char *W_R_ANY;
  499.   fclose(netfl);
  500.   makeSysName(tempname, "ctdlnet.sys", &cfg.netArea);
  501.   unlink(tempname);
  502.   if ((netfl = fopen(tempname, W_R_ANY)) == NULL)
  503.     {
  504.     crashout("Couldn't reopen net file!  (Return to your backups!)");
  505.  
  506.     }
  507.  
  508.   }
  509. /*
  510. * MailHandler()
  511. *
  512. * This function handles the contraction/expansion of MAILSLOTS.
  513. */
  514. void MailHandler()
  515.   {
  516.   int NewSize, i, old, r1, r2;
  517.   logBuffer *NewLog;
  518.   old = MAILSLOTS;
  519.   printf("Current messages per user in Mail is %d\n", MAILSLOTS);
  520.   NewSize = getUtilNumber("New size", 0, 65535);
  521.   if (NewSize == MAILSLOTS) return ;
  522.   NewLog = (logBuffer *) GetDynamic(sizeof logBuf * cfg.MAXLOGTAB);
  523.   for (i = 0; i < cfg.MAXLOGTAB; i++)
  524.     {
  525.     getLog(&logBuf, i);
  526.     movmem(&logBuf, NewLog + i, LB_SIZE);
  527.     MAILSLOTS = NewSize;
  528.     initLogBuf(&NewLog[i]);
  529.     MAILSLOTS = old;
  530.     for (r1 = MAILSLOTS-1, r2 = NewSize-1;
  531.     r1 != -1 && r2 != -1; r1--, r2--)
  532.       {
  533.       NewLog[i].lbMail[r2].rbmsgNo  = logBuf.lbMail[r1].rbmsgNo;
  534.       NewLog[i].lbMail[r2].rbmsgLoc = logBuf.lbMail[r1].rbmsgLoc;
  535.  
  536.       }
  537.     movmem(logBuf.lbgen, NewLog[i].lbgen, GEN_BULK);
  538.  
  539.     }
  540.   remakeLogFl();
  541.   killLogBuf(&logBuf);
  542.   MAILSLOTS = NewSize;
  543.   for (i = 0; i < cfg.MAXLOGTAB; i++)
  544.     {
  545.     movmem(NewLog + i, &logBuf, sizeof logBuf);
  546.     putLog(&logBuf, i);
  547.     killLogBuf(&logBuf);  /* this looks strange but works */
  548.  
  549.     }
  550.   DoFree(NewLog);
  551.   initLogBuf(&logBuf);
  552.   killRoomBuf(&roomBuf);
  553.   initRoomBuf(&roomBuf);
  554.   printf("Please remember to change your MAIL-SLOTS parameter to %d\n\n",
  555.   MAILSLOTS);
  556.  
  557.   }
  558. #define check(x) if (test) printf("%c\n", x);
  559. /*
  560. * SharedHandler()
  561. *
  562. * This function changes the number of shared rooms/system.
  563. */
  564. void SharedHandler()
  565.   {
  566.   int NewSize, i, old;
  567.   NetBuffer *NewNet;
  568.   char test;
  569.   old = SHARED_ROOMS;
  570.   printf("Current shared rooms/system is %d\n", SHARED_ROOMS);
  571.   NewSize = getUtilNumber("new shared rooms/system", 0, 65535);
  572.   if (NewSize == SHARED_ROOMS) return ;
  573.   if (cfg.netSize == 0)
  574.     {
  575.     SHARED_ROOMS = NewSize;
  576.     return ;
  577.  
  578.     }
  579.   if (NewSize < SHARED_ROOMS)
  580.   if (!getUYesNo("That value could result in losing shared rooms.  Continue"))
  581.   return;
  582.   test=FALSE;
  583.   NewNet = (NetBuffer *) GetDynamic(sizeof netBuf * cfg.netSize);
  584.   for (i = 0; i < cfg.netSize; i++)
  585.     {
  586.     check('a');
  587.     getNet(i, &netBuf);
  588.     check('b');
  589.     SHARED_ROOMS = NewSize;
  590.     initNetBuf(&NewNet[i]);
  591.     check('c');
  592.     movmem(&netBuf, NewNet + i, NB_SIZE);
  593.     check('d');
  594.     setmem(NewNet[i].netRooms, SR_BULK, 0);    /* 0 it */
  595.     check('e');
  596.     SHARED_ROOMS = old;
  597.     check('f');
  598.     movmem(netBuf.netRooms, NewNet[i].netRooms,
  599.     minimum(SR_BULK, (NewSize * (sizeof (SharedRoom)))));
  600.     check('g');
  601.  
  602.     }
  603.   /*test=TRUE;*/
  604.   check('1');
  605.   remakeNetFl();
  606.   killNetBuf(&netBuf);
  607.   SHARED_ROOMS = NewSize;
  608.   for (i = 0; i < cfg.netSize; i++)
  609.     {
  610.     check('z');
  611.     movmem(NewNet + i, &netBuf, sizeof netBuf);
  612.     check('y');
  613.     DoFree(netTab[i].netTRooms);
  614.     netTab[i].netTRooms = GetDynamic(SR_BULK);
  615.     check('x');
  616.     putNet(i, &netBuf);
  617.     check('w');
  618.     DoFree(netBuf.netRooms);
  619.     check('v');
  620.     check('u');
  621.  
  622.     }
  623.   check('2');
  624.   DoFree(NewNet);
  625.   initNetBuf(&netBuf);
  626.   printf("Please change your SHARED-ROOMS parameter to %d.\n\n",
  627.   SHARED_ROOMS);
  628.   check('3');
  629.  
  630.   }
  631.